package com.etong.frame.directive.impl.database;

import java.util.List;
import java.util.Map;

import com.alibaba.fastjson.JSON;
import com.etong.frame.directive.util.CommonStatus;

public class DatabaseUpdate extends DatabaseDirective {

	protected String fieldsConst = "";
	protected String whereConst = "";
	protected StringBuilder frontBuilder;
	protected StringBuilder updateBuilder;

	public String getStatementConfig() {
		return updateBuilder.toString();
	};

	public DatabaseUpdate(Statement statement) {
		super(statement);
	}

	public String getFieldsConst() {
		return fieldsConst;
	}

	public void setFieldsConst(String fieldsConst) {
		this.fieldsConst = fieldsConst;
	}

	public String getWhereConst() {
		return whereConst;
	}

	/**
	 * @Title : buildFields
	 * @Description : 组建更新的字段列表
	 * @params
	 * @param tableName
	 * @param fieldsExpr
	 *            设定文件
	 * @return void 返回类型
	 * @throws
	 */
	protected boolean buildFields(String fieldsExpr) {

		// 创建表字段
		List<String> fieldSplices = resolveFieldsConfig(fieldsExpr);
		for (String fieldExpr : fieldSplices) {
			Field field = createTableField(fieldExpr, BUILD_UPDATE);
			addPlaceholders(field.getPlaceholders());
			addTableField(field);
		}
		return true;
	}

	protected void buildWhere() {
		// 将where表达式的变量添加变量列表
		String whereExpr = getStatement().getWhere_expr();
		// Where表达式中的变量默认为必须的
		addPlaceholders(createPlaceholders(whereExpr, true));
		if (null != whereExpr && !whereExpr.isEmpty()) {
			whereConst = " where " + whereExpr;
		}
	}

	protected void buildComplete() {
		// 组建一个完整表达式，只包括常量字段部分
		logger.info("Build fields : " + JSON.toJSONString(getTableFields()));
		logger.info("Build update:" + getStatement().getName() + "->"
				+ frontBuilder.toString() + getWhereConst());

		updateBuilder.append(whereConst);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * com.etong.intercity.sqlbuilder.base.DefaultOp#buildConst(java.lang.String
	 * ) 编辑表达式中的常量部分
	 */
	@Override
	public boolean buildConst(Statement op) {

		// 组建Update字段列表
		buildFields(getStatement().getTable_fields());

		// 组建sql前面部分
		frontBuilder = new StringBuilder(256);
		frontBuilder.append("update ").append(getStatement().getTable_name())
				.append(" set ");

		// 配置组建器
		updateBuilder = new StringBuilder(256);
		updateBuilder.append(frontBuilder);

		// FIXME : 这里应该将常量表达式多列表中移除，在变量替换时可以减少遍历次数
		for (Field field : getTableFields()) {
			// 创建字段部分的常量表达式
			if (!field.isReplaced()) {
				frontBuilder.append(field.getName()).append(EQU)
						.append(field.getValue()).append(DOT);
			}
			updateBuilder.append(field.getName()).append(EQU)
					.append(field.getValue()).append(DOT);
		}

		buildWhere();
		buildComplete();

		return true;
	}

	@Override
	protected CommonStatus buildVariable(Map<String, Object> vars) {

		CommonStatus status = new CommonStatus();

		// 字段名的表达式
		StringBuilder builder = new StringBuilder(256);
		builder.append(frontBuilder);

		boolean haveFields = false;
		for (Field field : getTableFields()) {
			// 判断是否需要进行替换的变量字段
			if (field.isReplaced()) {
				String fieldValue = field.getValue();
				String fieldName = field.getName();
				// 如果字段是必须的，但不存在该变量
				boolean fieldValid = true;
				for (Placeholder placeholder : field.getPlaceholders()) {
					if (!vars.containsKey(placeholder.getName())) {
						fieldValid = false;
					}
				}

				if (fieldValid) {
					builder.append(fieldName).append(EQU).append(fieldValue)
							.append(DOT);
					haveFields = true;
				} else {
					if (field.isRequired()) {
						status.error(CommonStatus.DIRECTIVE_CREATE_ERROR,
								"Required var no set:" + fieldValue);
						return status;
					}
				}
			}
		}

		// 去掉变量表达式中的第一个DOT，因为表达式已经结束
		if (haveFields) {
			builder.deleteCharAt(builder.length() - 1);
		}

		// 添加条件表达式
		builder.append(whereConst);
		status.setObject(builder.toString());

		return status;
	}

}
